package org.Yiran.timetale_re.block;

import net.minecraft.world.level.block.Block;
import net.minecraft.world.level.block.SoundType;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;
import net.minecraftforge.registries.RegistryObject;
import org.Yiran.timetale_re.Timetale_re;
import org.Yiran.timetale_re.block.crystal.ChaosCrystalBlock;
import org.Yiran.timetale_re.block.crystal.DimensionCrystalBlock;
import org.Yiran.timetale_re.block.crystal.SpaceCrystalBlock;
import org.Yiran.timetale_re.block.crystal.TimeCrystalBlock;
import org.Yiran.timetale_re.block.crystal.EnergyCrystalClusterBlock; // 添加导入
import org.Yiran.timetale_re.block.decorate.Chair;
import org.Yiran.timetale_re.block.decorate.longtable.LongTable;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

/**
 * 方块注册类
 * 管理模组中所有方块的注册和访问
 * <p>
 * 主要功能:
 * 1. 使用DeferredRegister系统注册所有方块
 * 2. 通过枚举管理方块，便于维护和扩展
 * 3. 提供方块访问接口
 */
public class BlocksRegister {
    
    // ==================== 注册器定义 ====================
    
    /** 方块注册器 */
    public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, Timetale_re.MODID);

    // ==================== 方块枚举管理 ====================

    /**
     * 模组方块枚举
     * 通过枚举管理所有方块，便于统一注册和访问
     */
    public enum ModBlocks {
        /** 混沌水晶方块 */
        CHAOS_CRYSTAL(
                "chaos_crystal",
                ChaosCrystalBlock::new,
                MineableType.PICKAXE,
                2 // 铁工具等级
        ),
        
        /** 时间水晶方块 */
        TIME_CRYSTAL(
                "time_crystal",
                TimeCrystalBlock::new,
                MineableType.PICKAXE,
                2 // 铁工具等级
        ),
        
        /** 次元水晶方块 */
        DIMENSION_CRYSTAL(
                "dimension_crystal",
                DimensionCrystalBlock::new,
                MineableType.PICKAXE,
                2 // 铁工具等级
        ),
        
        /** 空间水晶方块 */
        SPACE_CRYSTAL(
                "space_crystal",
                SpaceCrystalBlock::new,
                MineableType.PICKAXE,
                2 // 铁工具等级
        ),
        
        /** 能晶簇方块 */
        ENERGY_CRYSTAL_CLUSTER(
                "energy_crystal_cluster",
                EnergyCrystalClusterBlock::new,
                MineableType.PICKAXE,
                1 // 石头工具等级
        ),
        
        /** 长桌方块 */
        LONG_TABLE("long_table", () -> new LongTable(
                Block.Properties.of()
                        .strength(2.0f, 3.0f)
                        .noOcclusion()
                        .sound(SoundType.WOOD), 
                "timetale_re", 
                "long_table"), MineableType.AXE, 0 // 木工具等级
        ),
        
        /** 椅子方块 */
        CHAIR("chair", () -> new Chair(
                Block.Properties.of()
                        .strength(1.5f, 2.0f)
                        .sound(SoundType.WOOD), 
                "timetale_re", 
                "chair"), MineableType.AXE, 0 // 木工具等级
        );

        /** 方块名称 */
        private final String name;
        
        /** 方块提供器 */
        private final Supplier<? extends Block> supplier;
        
        /** 注册后的方块对象 */
        private RegistryObject<Block> block;
        
        /** 可挖掘类型 */
        private final MineableType mineableType;
        
        /** 挖掘等级 */
        private final int harvestLevel;

        /**
         * 构造函数
         * @param name 方块名称
         * @param supplier 方块提供器
         * @param mineableType 可挖掘类型
         */
        ModBlocks(String name, Supplier<? extends Block> supplier, MineableType mineableType) {
            this(name, supplier, mineableType, 0);
        }
        
        /**
         * 构造函数
         * @param name 方块名称
         * @param supplier 方块提供器
         * @param mineableType 可挖掘类型
         * @param harvestLevel 挖掘等级
         */
        ModBlocks(String name, Supplier<? extends Block> supplier, MineableType mineableType, int harvestLevel) {
            this.name = name;
            this.supplier = supplier;
            this.mineableType = mineableType;
            this.harvestLevel = harvestLevel;
        }

        /**
         * 注册所有方块
         * @param registry 方块注册器
         */
        public static void register(DeferredRegister<Block> registry) {
            for (ModBlocks modBlock : values()) {
                modBlock.block = registry.register(modBlock.name, modBlock.supplier);
            }
        }

        /**
         * 获取注册后的方块对象
         * @return 注册后的方块对象
         */
        public RegistryObject<Block> getBlock() {
            return block;
        }

        /**
         * 获取方块的可挖掘类型
         * @return 可挖掘类型
         */
        public MineableType getMineableType() {
            return mineableType;
        }
        
        /**
         * 获取方块的挖掘等级
         * @return 挖掘等级
         */
        public int getHarvestLevel() {
            return harvestLevel;
        }

        /**
         * 获取所有已注册的方块
         * @return 方块列表
         */
        public static List<RegistryObject<Block>> getAllBlocks() {
            List<RegistryObject<Block>> blocks = new ArrayList<>();
            for (ModBlocks modBlock : values()) {
                if (modBlock.block != null) {
                    blocks.add(modBlock.block);
                }
            }
            return blocks;
        }
        
        /**
         * 根据可挖掘类型获取方块列表
         * @param type 可挖掘类型
         * @return 对应类型的方块列表
         */
        public static List<ModBlocks> getBlocksByMineableType(MineableType type) {
            List<ModBlocks> blocks = new ArrayList<>();
            for (ModBlocks modBlock : values()) {
                if (modBlock.mineableType == type) {
                    blocks.add(modBlock);
                }
            }
            return blocks;
        }
    }
    
    /**
     * 可挖掘类型枚举
     * 定义方块可以被哪种工具挖掘
     */
    public enum MineableType {
        /** 镐 */
        PICKAXE,
        /** 斧 */
        AXE,
        /** 铲 */
        SHOVEL,
        /** 凿子 */
        CHISEL,
        /** 无需工具 */
        NONE
    }

    // ==================== 静态初始化 ====================

    /* 静态初始化块，注册所有方块 */
    static {
        ModBlocks.register(BLOCKS);
    }

    // ==================== 方块访问接口 ====================

    /** 混沌水晶方块访问接口 */
    public static final RegistryObject<Block> CHAOS_CRYSTAL = ModBlocks.CHAOS_CRYSTAL.getBlock();
    
    /** 时间水晶方块访问接口 */
    public static final RegistryObject<Block> TIME_CRYSTAL = ModBlocks.TIME_CRYSTAL.getBlock();
    
    /** 次元水晶方块访问接口 */
    public static final RegistryObject<Block> DIMENSION_CRYSTAL = ModBlocks.DIMENSION_CRYSTAL.getBlock();
    
    /** 空间水晶方块访问接口 */
    public static final RegistryObject<Block> SPACE_CRYSTAL = ModBlocks.SPACE_CRYSTAL.getBlock();
    
    /** 能晶簇方块访问接口 */
    public static final RegistryObject<Block> ENERGY_CRYSTAL_CLUSTER = ModBlocks.ENERGY_CRYSTAL_CLUSTER.getBlock();
    
    /** 长桌方块访问接口 */
    public static final RegistryObject<Block> LONG_TABLE = ModBlocks.LONG_TABLE.getBlock();
    
    /** 椅子方块访问接口 */
    public static final RegistryObject<Block> CHAIR = ModBlocks.CHAIR.getBlock();
}